namespace ext.dd
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// This class provides a container DD instance that allows dropping on multiple child target nodes.  By default, this class requires that child nodes accepting drop are registered with {@link Ext.dd.Registry}.
	/// However a simpler way to allow a DropZone to manage any number of target elements is to configure the
	/// DropZone with an implementation of {@link #getTargetFromEvent} which interrogates the passed
	/// mouse event to see if it has taken place within an element, or class of elements. This is easily done
	/// by using the event&apos;s {@link Ext.EventObject#getTarget getTarget} method to identify a node based on a
	/// {@link Ext.DomQuery} selector.  Once the DropZone has detected through calling getTargetFromEvent, that the mouse is over
	/// a drop target, that target is passed as the first parameter to {@link #onNodeEnter}, {@link #onNodeOver},
	/// {@link #onNodeOut}, {@link #onNodeDrop}. You may configure the instance of DropZone with implementations
	/// of these methods to provide application-specific...
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;This class provides a container DD instance that allows dropping on multiple child target nodes.&lt;/p&gt;
	/// &lt;p&gt;By default, this class requires that child nodes accepting drop are registered with {@link Ext.dd.Registry}.
	/// However a simpler way to allow a DropZone to manage any number of target elements is to configure the
	/// DropZone with an implementation of {@link #getTargetFromEvent} which interrogates the passed
	/// mouse event to see if it has taken place within an element, or class of elements. This is easily done
	/// by using the event&apos;s {@link Ext.EventObject#getTarget getTarget} method to identify a node based on a
	/// {@link Ext.DomQuery} selector.&lt;/p&gt;
	/// &lt;p&gt;Once the DropZone has detected through calling getTargetFromEvent, that the mouse is over
	/// a drop target, that target is passed as the first parameter to {@link #onNodeEnter}, {@link #onNodeOver},
	/// {@link #onNodeOut}, {@link #onNodeDrop}. You may configure the instance of DropZone with implementations
	/// of these methods to provide application-specific behaviour for these events to update both
	/// application state, and UI state.&lt;/p&gt;
	/// &lt;p&gt;For example to make a GridPanel a cooperating target with the example illustrated in
	/// {@link Ext.dd.DragZone DragZone}, the following technique might be used:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
	/// myGridPanel.on(&apos;render&apos;, function() {
	/// myGridPanel.dropZone = new Ext.dd.DropZone(myGridPanel.getView().scroller, {
	///
	/// // If the mouse is over a grid row, return that node. This is
	/// // provided as the &quot;target&quot; parameter in all &quot;onNodeXXXX&quot; node event handling functions
	/// getTargetFromEvent: function(e) {
	/// return e.getTarget(myGridPanel.getView().rowSelector);
	/// },
	///
	/// // On entry into a target node, highlight that node.
	/// onNodeEnter : function(target, dd, e, data){
	/// Ext.fly(target).addClass(&apos;my-row-highlight-class&apos;);
	/// },
	///
	/// // On exit from a target node, unhighlight that node.
	/// onNodeOut : function(target, dd, e, data){
	/// Ext.fly(target).removeClass(&apos;my-row-highlight-class&apos;);
	/// },
	///
	/// // While over a target node, return the default drop allowed class which
	/// // places a &quot;tick&quot; icon into the drag proxy.
	/// onNodeOver : function(target, dd, e, data){
	/// return Ext.dd.DropZone.prototype.dropAllowed;
	/// },
	///
	/// // On node drop we can interrogate the target to find the underlying
	/// // application object that is the real target of the dragged data.
	/// // In this case, it is a Record in the GridPanel&apos;s Store.
	/// // We can use the data set up by the DragZone&apos;s getDragData method to read
	/// // any data we decided to attach in the DragZone&apos;s getDragData method.
	/// onNodeDrop : function(target, dd, e, data){
	/// var rowIndex = myGridPanel.getView().findRowIndex(target);
	/// var r = myGridPanel.getStore().getAt(rowIndex);
	/// Ext.Msg.alert(&apos;Drop gesture&apos;, &apos;Dropped Record id &apos; + data.draggedRecord.id +
	/// &apos; on Record id &apos; + r.id);
	/// return true;
	/// }
	/// });
	/// }
	/// &lt;/code&gt;&lt;/pre&gt;
	/// See the {@link Ext.dd.DragZone DragZone} documentation for details about building a DragZone which
	/// cooperates with this DropZone.
	/// </htmlSummary>
	/// <definedin>src\dd\DropZone.js</definedin>
	[ScriptName("DropZone")]
	[ScriptNamespace("Ext.dd")]
	[Imported()]
	public partial class DropZone : ext.dd.DropTarget
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		/// <param name="el">The container element</param>
		/// <param name="config"></param>
		public DropZone(object el, object config)
		{
		}
		
		/// <summary>Constructor</summary>
		public DropZone()
		{
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Returns a custom data object associated with the DOM node that is the target of the event. By default
		/// this looks up the event target in the {@link Ext.dd.Registry}, although you can override this method to
		/// provide your own custom lookup.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="e">The event</param>
		/// <returns>data The custom data</returns>
		[ScriptName("getTargetFromEvent")]
		public object GetTargetFromEvent(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Called when the DropZone determines that a {@link Ext.dd.DragSource} has entered a drop node
		/// that has either been registered or detected by a configured implementation of {@link #getTargetFromEvent}.
		/// This method has no default implementation and should be overridden to provide
		/// node-specific processing if necessary.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="nodeData">
		/// The custom data associated with the drop node (this is the same value returned from
		/// {@link #getTargetFromEvent} for this node)
		/// </param>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		[ScriptName("onNodeEnter")]
		public void OnNodeEnter(object nodeData, ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Called while the DropZone determines that a {@link Ext.dd.DragSource} is over a drop node
		/// that has either been registered or detected by a configured implementation of {@link #getTargetFromEvent}.
		/// The default implementation returns this.dropNotAllowed, so it should be
		/// overridden to provide the proper feedback.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="nodeData">
		/// The custom data associated with the drop node (this is the same value returned from
		/// {@link #getTargetFromEvent} for this node)
		/// </param>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>
		/// status The CSS class that communicates the drop status back to the source so that the
		/// underlying {@link Ext.dd.StatusProxy} can be updated
		/// </returns>
		[ScriptName("onNodeOver")]
		public string OnNodeOver(object nodeData, ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dragged out of
		/// the drop node without dropping. This method has no default implementation and should be overridden to provide
		/// node-specific processing if necessary.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="nodeData">
		/// The custom data associated with the drop node (this is the same value returned from
		/// {@link #getTargetFromEvent} for this node)
		/// </param>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		[ScriptName("onNodeOut")]
		public void OnNodeOut(object nodeData, ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped onto
		/// the drop node. The default implementation returns false, so it should be overridden to provide the
		/// appropriate processing of the drop event and return true so that the drag source&apos;s repair action does not run.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="nodeData">
		/// The custom data associated with the drop node (this is the same value returned from
		/// {@link #getTargetFromEvent} for this node)
		/// </param>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>True if the drop was valid, else false</returns>
		[ScriptName("onNodeDrop")]
		public bool OnNodeDrop(object nodeData, ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Called while the DropZone determines that a {@link Ext.dd.DragSource} is being dragged over it,
		/// but not over any of its registered drop nodes. The default implementation returns this.dropNotAllowed, so
		/// it should be overridden to provide the proper feedback if necessary.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>
		/// status The CSS class that communicates the drop status back to the source so that the
		/// underlying {@link Ext.dd.StatusProxy} can be updated
		/// </returns>
		[ScriptName("onContainerOver")]
		public string OnContainerOver(ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped on it,
		/// but not on any of its registered drop nodes. The default implementation returns false, so it should be
		/// overridden to provide the appropriate processing of the drop event if you need the drop zone itself to
		/// be able to accept drops. It should return true when valid so that the drag source&apos;s repair action does not run.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>True if the drop was valid, else false</returns>
		[ScriptName("onContainerDrop")]
		public bool OnContainerDrop(ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the source is now over
		/// the zone. The default implementation returns this.dropNotAllowed and expects that only registered drop
		/// nodes can process drag drop operations, so if you need the drop zone itself to be able to process drops
		/// you should override this method and provide a custom implementation.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>
		/// status The CSS class that communicates the drop status back to the source so that the
		/// underlying {@link Ext.dd.StatusProxy} can be updated
		/// </returns>
		[ScriptName("notifyEnter")]
		public string NotifyEnter(ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// The function a {@link Ext.dd.DragSource} calls continuously while it is being dragged over the drop zone.
		/// This method will be called on every mouse movement while the drag source is over the drop zone.
		/// It will call {@link #onNodeOver} while the drag source is over a registered node, and will also automatically
		/// delegate to the appropriate node-specific methods as necessary when the drag source enters and exits
		/// registered nodes ({@link #onNodeEnter}, {@link #onNodeOut}). If the drag source is not currently over a
		/// registered node, it will call {@link #onContainerOver}.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>
		/// status The CSS class that communicates the drop status back to the source so that the
		/// underlying {@link Ext.dd.StatusProxy} can be updated
		/// </returns>
		[ScriptName("notifyOver")]
		public string NotifyOver(ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the source has been dragged
		/// out of the zone without dropping. If the drag source is currently over a registered node, the notification
		/// will be delegated to {@link #onNodeOut} for node-specific handling, otherwise it will be ignored.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="source">The drag source that was dragged over this drop target</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag zone</param>
		[ScriptName("notifyOut")]
		public void NotifyOut(ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the dragged item has
		/// been dropped on it. The drag zone will look up the target node based on the event passed in, and if there
		/// is a node registered for that event, it will delegate to {@link #onNodeDrop} for node-specific handling,
		/// otherwise it will call {@link #onContainerDrop}.
		/// </summary>
		/// <definedin>src\dd\DropZone.js</definedin>
		/// <param name="source">The drag source that was dragged over this drop zone</param>
		/// <param name="e">The event</param>
		/// <param name="data">An object containing arbitrary data supplied by the drag source</param>
		/// <returns>True if the drop was valid, else false</returns>
		[ScriptName("notifyDrop")]
		public bool NotifyDrop(ext.dd.DragSource source, System.Html.ElementEvent e, object data)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
